/**
 * 工具函数集合
 */
const Utils = {
    /**
     * 生成指定范围内的随机整数
     * @param {number} min - 最小值（包含）
     * @param {number} max - 最大值（包含）
     * @returns {number} 随机整数
     */
    randomInt(min, max) {
        return Math.floor(Math.random() * (max - min + 1)) + min;
    },
    
    /**
     * 生成随机浮点数
     * @param {number} min - 最小值（包含）
     * @param {number} max - 最大值（不包含）
     * @returns {number} 随机浮点数
     */
    randomFloat(min, max) {
        return Math.random() * (max - min) + min;
    },
    
    /**
     * 根据概率返回布尔值
     * @param {number} probability - 概率值（0-1之间）
     * @returns {boolean} 是否命中
     */
    chance(probability) {
        return Math.random() < probability;
    },
    
    /**
     * 从数组中随机选择n个元素
     * @param {Array} array - 源数组
     * @param {number} n - 选择数量
     * @returns {Array} 选中的元素数组
     */
    randomSample(array, n) {
        const shuffled = [...array].sort(() => 0.5 - Math.random());
        return shuffled.slice(0, n);
    },
    
    /**
     * 根据权重随机选择一个元素
     * @param {Array} items - 元素数组
     * @param {Array} weights - 对应的权重数组
     * @returns {*} 选中的元素
     */
    weightedRandom(items, weights) {
        const totalWeight = weights.reduce((sum, weight) => sum + weight, 0);
        let random = Math.random() * totalWeight;
        
        for (let i = 0; i < items.length; i++) {
            if (random < weights[i]) {
                return items[i];
            }
            random -= weights[i];
        }
        
        return items[items.length - 1];
    },
    
    /**
     * 生成唯一ID
     * @returns {string} 唯一ID
     */
    generateId() {
        return Date.now().toString(36) + Math.random().toString(36).substr(2, 5);
    },
    
    /**
     * 格式化数字（添加千位分隔符）
     * @param {number} num - 要格式化的数字
     * @returns {string} 格式化后的字符串
     */
    formatNumber(num) {
        return num.toString().replace(/\B(?=(\d{3})+(?!\d))/g, ",");
    },
    
    /**
     * 生成随机名称
     * @param {string} type - 名称类型（'kingdom'或'npc'）
     * @param {number} raceId - 种族ID
     * @returns {string} 随机生成的名称
     */
    generateRandomName(type, raceId) {
        // 王国名称生成
        if (type === 'kingdom') {
            const prefixes = ['永恒', '辉煌', '神圣', '黄金', '白银', '青铜', '黑铁', '翡翠', '红玉', '蓝宝'];
            const suffixes = ['王国', '帝国', '联邦', '共和国', '领地', '城邦', '同盟'];
            
            // 根据种族ID选择不同的前缀风格
            let racePrefix = '';
            switch(raceId) {
                case 1: // 精灵族
                    racePrefix = ['银月', '星辰', '翠叶', '风歌', '光明'][Utils.randomInt(0, 4)];
                    break;
                case 2: // 兽人族
                    racePrefix = ['血牙', '钢斧', '狂怒', '战歌', '铁拳'][Utils.randomInt(0, 4)];
                    break;
                case 3: // 矮人族
                    racePrefix = ['铁炉', '石墙', '深山', '金矿', '锻造'][Utils.randomInt(0, 4)];
                    break;
                case 4: // 人族
                    racePrefix = ['白云', '青山', '长河', '平原', '丰收'][Utils.randomInt(0, 4)];
                    break;
                case 5: // 亡灵族
                    racePrefix = ['暗影', '骨灰', '死亡', '幽魂', '凋零'][Utils.randomInt(0, 4)];
                    break;
                default:
                    racePrefix = prefixes[Utils.randomInt(0, prefixes.length - 1)];
            }
            
            const suffix = suffixes[Utils.randomInt(0, suffixes.length - 1)];
            return `${racePrefix}${suffix}`;
        }
        
        // NPC名称生成
        if (type === 'npc') {
            // 根据种族生成不同风格的名字
            const firstNames = {
                1: ['艾', '莉', '瑟', '伊', '奥', '凯', '莱', '塔', '提', '露'], // 精灵族
                2: ['格', '洛', '萨', '杜', '克', '巴', '扎', '古', '鲁', '纳'], // 兽人族
                3: ['索', '林', '巴', '德', '吉', '姆', '托', '瑞', '弗', '诺'], // 矮人族
                4: ['李', '王', '张', '刘', '陈', '杨', '赵', '黄', '周', '吴'], // 人族
                5: ['亚', '莫', '斯', '卡', '拉', '西', '娜', '尔', '提', '乌']  // 亡灵族
            };
            
            const lastNames = {
                1: ['星辰', '月影', '风行', '光明', '森林', '晨曦', '夜歌', '流水', '天空', '叶影'], // 精灵族
                2: ['血斧', '石牙', '雷吼', '狂战', '碎骨', '钢臂', '火眼', '熊心', '狼魂', '虎爪'], // 兽人族
                3: ['铁锤', '石墙', '金矿', '银须', '铜炉', '钢盔', '岩心', '山脉', '宝石', '地底'], // 矮人族
                4: ['明', '华', '强', '伟', '勇', '军', '杰', '涛', '超', '刚'], // 人族
                5: ['亡魂', '暗影', '死骨', '幽灵', '凋零', '腐朽', '黑暗', '恐惧', '哀嚎', '寂灭']  // 亡灵族
            };
            
            // 如果没有对应种族的名字库，使用默认名字
            const raceFirstNames = firstNames[raceId] || firstNames[4];
            const raceLastNames = lastNames[raceId] || lastNames[4];
            
            const firstName = raceFirstNames[Utils.randomInt(0, raceFirstNames.length - 1)];
            const lastName = raceLastNames[Utils.randomInt(0, raceLastNames.length - 1)];
            
            return `${firstName}·${lastName}`;
        }
        
        return "未命名";
    },
    
    /**
     * 添加事件日志
     * @param {string} message - 日志消息
     * @param {string} type - 日志类型（'normal', 'important', 'positive'）
     */
    addLogEntry(message, type = 'normal') {
        const logEntries = document.getElementById('log-entries');
        const entry = document.createElement('div');
        entry.className = `log-entry ${type}`;
        entry.textContent = `[${Game.currentYear}年] ${message}`;
        
        // 添加到顶部
        logEntries.insertBefore(entry, logEntries.firstChild);
        
        // 限制日志条数
        const maxEntries = 50;
        while (logEntries.children.length > maxEntries) {
            logEntries.removeChild(logEntries.lastChild);
        }
    },
    
    /**
     * 保存游戏数据到localStorage
     * @param {string} slotName - 存档槽名称
     * @param {Object} gameData - 游戏数据
     */
    saveGame(slotName, gameData) {
        return new Promise((resolve) => {
            const request = indexedDB.open('LostContinentDB', 1);

            request.onupgradeneeded = (event) => {
                const db = event.target.result;
                if (!db.objectStoreNames.contains('saves')) {
                    db.createObjectStore('saves', { keyPath: 'slotName' });
                }
            };

            request.onsuccess = (event) => {
                const db = event.target.result;
                const transaction = db.transaction('saves', 'readwrite');
                const store = transaction.objectStore('saves');
                
                const saveData = {
                    slotName: `lostcontinent_${slotName}`,
                    data: gameData,
                    timestamp: Date.now()
                };
                
                const putRequest = store.put(saveData);
                
                putRequest.onsuccess = () => {
                    resolve(true);
                };
                
                putRequest.onerror = (error) => {
                    console.error('保存游戏失败:', error.target.error);
                    resolve(false);
                };
            };

            request.onerror = (error) => {
                console.error('数据库打开失败:', error.target.error);
                resolve(false);
            };
        });
    },
    
    /**
     * 从localStorage加载游戏数据
     * @param {string} slotName - 存档槽名称
     * @returns {Object|null} 游戏数据或null
     */
    loadGame(slotName) {
        return new Promise((resolve) => {
            const request = indexedDB.open('LostContinentDB', 1);

            request.onsuccess = (event) => {
                const db = event.target.result;
                const transaction = db.transaction('saves', 'readonly');
                const store = transaction.objectStore('saves');
                
                const getRequest = store.get(`lostcontinent_${slotName}`);
                
                getRequest.onsuccess = () => {
                    resolve(getRequest.result ? getRequest.result.data : null);
                };
                
                getRequest.onerror = (error) => {
                    console.error('加载游戏失败:', error.target.error);
                    resolve(null);
                };
            };

            request.onerror = (error) => {
                console.error('数据库打开失败:', error.target.error);
                resolve(null);
            };
        });
    },
    
    /**
     * 获取所有存档槽
     * @returns {Array} 存档槽数组
     */
    getSaveSlots() {
        const slots = [];
        for (let i = 0; i < localStorage.length; i++) {
            const key = localStorage.key(i);
            if (key.startsWith('lostcontinent_')) {
                const slotName = key.replace('lostcontinent_', '');
                const data = JSON.parse(localStorage.getItem(key));
                slots.push({
                    name: slotName,
                    year: data.currentYear,
                    timestamp: data.timestamp
                });
            }
        }
        return slots.sort((a, b) => b.timestamp - a.timestamp);
    },

    /**
     * 将日志内容追加到日志文件
     * @param {string} message - 日志消息
     */
    appendToLogFile(message) {
        // 模拟日志文件追加操作
        console.log(`[日志文件] ${message}`);
    }
};